import {TableInfo} from "../../types";
import {TypeValidationUtil} from "./TypeValidationUtil";

/**
 * 实体类型处理工具类，负责处理实体对象的类型转换和校验
 */
export class EntityTypeProcessor {
  /**
   * 处理实体对象的类型转换和校验
   * @param entity 要处理的实体对象
   * @param tableInfo 表信息
   * @param strictTypeCheck 是否启用严格类型检查
   * @returns 处理后的实体对象与处理的字段信息
   */
  static processEntityData<T>(
    entity: Record<string, any>,
    tableInfo: TableInfo<T>,
    strictTypeCheck: boolean
  ): {
    processedData: Record<string, any>;
    keys: string[];
    values: any[];
  } {
    const processedData: Record<string, any> = {};
    const keys: string[] = [];
    const values: any[] = [];

    for (const [key, value] of Object.entries(entity)) {
      const column = tableInfo.columns[key as keyof T];
      if (column) {
        // 应用类型校验或转换
        const processedValue = TypeValidationUtil.validateOrConvertValue(
          value,
          column.type,
          strictTypeCheck
        );
        processedData[key] = processedValue;
        keys.push(key);
        values.push(processedValue);
      } else {
        // 如果没有列定义，直接使用原始值
        processedData[key] = value;
        keys.push(key);
        values.push(value);
      }
    }

    return {processedData, keys, values};
  }

  /**
   * 处理WHERE条件的类型转换和校验
   * @param whereCondition WHERE条件对象
   * @param tableInfo 表信息
   * @param strictTypeCheck 是否启用严格类型检查
   * @returns 处理后的WHERE条件对象
   */
  static processWhereCondition<T>(
    whereCondition: Record<string, any>,
    tableInfo: TableInfo<T>,
    strictTypeCheck: boolean = false // 对于WHERE条件，默认不启用严格检查
  ): Record<string, any> {
    const processedCondition: Record<string, any> = {};

    for (const [key, value] of Object.entries(whereCondition)) {
      const column = tableInfo.columns[key as keyof T];
      if (column) {
        // 应用类型校验或转换
        processedCondition[key] = TypeValidationUtil.validateOrConvertValue(
          value,
          column.type,
          strictTypeCheck
        );
      } else {
        // 如果没有列定义，直接使用原始值
        processedCondition[key] = value;
      }
    }

    return processedCondition;
  }

  /**
   * 处理单个字段值的类型转换和校验
   * @param fieldName 字段名
   * @param value 字段值
   * @param tableInfo 表信息
   * @param strictTypeCheck 是否启用严格类型检查
   * @returns 处理后的字段值
   */
  static processFieldValue<T>(
    fieldName: keyof T & string,
    value: any,
    tableInfo: TableInfo<T>,
    strictTypeCheck: boolean
  ): any {
    // 对于特殊输入，直接返回
    if (value === undefined || value === null) {
      return value;
    }

    // 检查是否有字段定义
    const column = tableInfo.columns[fieldName];
    if (!column) {
      return value;
    }

    // 进行类型校验或转换
    return TypeValidationUtil.validateOrConvertValue(value, column.type, strictTypeCheck);
  }
}
